<?php
/**
 * Description of Utility
 * in questa classe sono presenti delle funzioni di
 * utilizzo generale
 *
 * @author francesco
 */
class Utility {
    
    // vettore contenente tutto il flusso di un determinato processo
    private $_flusso_id = null;
    
    /**
     * constructor 
     * 
     * @param array $params 
     */
    public function __construct()
    {
        $this->_flusso_id = array();
    }
    
    /**
     * getter per flussoID
     * 
     * @return type 
     */
    public function get_flusso(){
        return $this->_flusso_id;
    }
    
    /**
     * Questo metodo ritorna il percorso per arrivare a quella fase
     * esso è unico dato che una fase ha un solo padre
     * 
     * @param type $id_fase 
     * @return true se tutto è andato bene
     */
    public function crea_percorso_da_fase($id_fase){
       // prendo padre fino alla radice e poi inverto tutto e stampo
       // vettore di ritorno
       $flusso=array();
       // accesso al db
       require_once APPLICATION_PATH . '/models/Db/Flusso_db.php';
       $db_flusso = new Flusso_db();
       // prendo la fase corrente
       $fase_corrente=$db_flusso->getFaseDaId($id_fase);
       // se esiste il padre ciclo
       while($fase_corrente['id_padre']!=0){
           array_push($flusso, $fase_corrente['id_fase']); // aggiungo allo stack
           // prendo la nuova fase corrente
           $fase_corrente=$db_flusso->getFaseDaId($fase_corrente['id_padre']);
       }
       if($fase_corrente['id_padre']==0) // se sono arrivato alla radice
           array_push($flusso, $fase_corrente['id_fase']); // aggiungo allo stack
       $flusso=array_reverse($flusso);
       $this->_flusso_id=$flusso;
       
       return true;
    }
    
    /**
     *  Questo metodo restituisce un vettore contenente i nomi delle fasi
     * contenenti in flusso id
     */
    public function get_nomi_flusso(){
        // vettore contenente i nomi flusso
        $flusso_nome= array();
        // metodi per il db
        require_once APPLICATION_PATH . '/models/Db/Flusso_db.php';
        $db= new Flusso_db();
        // prendo il vettore contenente tutti gli id del flusso
        $flusso=$this->get_flusso();
        foreach($flusso as $flussoNodo){
            $nodo=$db->getNodi($flussoNodo);
            array_push($flusso_nome,$nodo['descrizione']);
        }
        return $flusso_nome;
    }
    
    /**
     * Questo metodo restituisce un vettore ordinato di id_fase
     * dato un'id processo che rappresenta la stampa di tutto l'albero
     * ordinato
     *
     * @param type $radice la radice dell'albero
     * @param type $id_tipo_processo il tipo di processo: distingue quali fasi prendere
     */
    public function padre_figlio_walk($nodo_corrente,$id_tipo_processo){
        // array foglie ordinato 
        // includo la classe per il db
        require_once APPLICATION_PATH . '/models/Db/Flusso_db.php';
        $db= new Flusso_db();
        // aggiunge il nodo corrente
        array_push($this->_flusso_id, $nodo_corrente);
        // prendi tutti i nodi figli
        $figli=$db->getNodiFigli($id_tipo_processo, $nodo_corrente);
        //condizione di terminazione
        if(!$figli){
            return;
        }
        // per ogni nodo figlio chiama f()
        foreach($figli as $nodo_figlio){
            Utility::padre_figlio_walk($nodo_figlio['id_fase'], $id_tipo_processo);
        }
    }
    
    
    
    /**
     *
     * Questa funzione taglia il $text in ingresso al mnumero di caratteri $max_length
     * e inserisce alla fine $tail.
     * 
     * @param type $text
     * @param type $max_length
     * @param type $tail
     * @return string 
     */
    public static function trim_body($text, $max_length = 500, $tail = '... <i>continua</i>') {
          $tail_len = strlen($tail);
          if (strlen($text) > $max_length) {
              $tmp_text = substr($text, 0, $max_length - $tail_len);
              if (substr($text, $max_length - $tail_len, 1) == ' ') {
                  $text = $tmp_text;
              }
              else {
                  $pos = strrpos($tmp_text, ' ');
                  $text = substr($text, 0, $pos);
		}
              $text = $text . $tail;
          }
          return $text;
      }    
      
      
    /**
     *
     * Ordino in ordine alfabetico (in base 
     * alle chiavi) un array multidimensionale
     * 
     * in ingresso l'array e il nome della key per cui 
     * ordinare l'arry
     * 
     * @param array $array
     * @param string $value
     * @return array
     *  
     */
    public static function alphaSort($array, $value){
            
            # inizializziamo un ciclo for che abbia come condizione di terminazione
            # il numero degli array interni meno "1"
            for ($i=0;$i<count($array)-1;$i++) {
                # inizializziamo un ciclo for che abbia come condizione di terminazione
                # il numero degli array
                for ($j=$i+1;$j<count($array);$j++) {
                    # utilizziamo come indici i valori derivanti dall'iterazione dei cicli e utilizziamoli
                    # per effettuare un controllo tra valori 
                    $ordina = strcmp($array[$i]["$value"], $array[$j]["$value"]);

                    # ordiniamo i valori sulla base dei confronti ponendo per primi
                    # i valori alfabeticamente "maggiori" 
                    if ($ordina > 0) {
                      $ordinato = $array[$i];
                      $array[$i] = $array[$j];
                      $array[$j] = $ordinato;
                    }
                }
            }
        return $array;
      }
      
      

    /**
     *
     * @param <type> $a
     * @param <type> $subkey
     * @return <type>
     */
    public static function subval_sort($a, $subkey){
        foreach($a as $k=>$v) {
        		$b[$k] = strtolower($v[$subkey]);
        	}
        	asort($b);
        	foreach($b as $key=>$val) {
        		$c[] = $a[$key];
        	}
        	return $c;
    }     
    

    /**
     * 
     * array_unique function to handle deep arrays
     * 
     * @param multidimensional array $array
     * @return array 
     */
    public static function array_unique_deep($array) {
        $values=array();
        //ideally there would be some is_array() testing for $array here...
        foreach ($array as $part) {
            if (is_array($part)) $values=array_merge($values, Utility::array_unique_deep($part));
            else $values[]=$part;
        }
        return array_unique($values);
    }


    public static function specified_array_unique($array, $value)
    {
        $count = 0;
        foreach($array as $array_key => $array_value)
        {
            if ( ($count > 0) && ($array_value == $value) ){
                unset($array[$array_key]);
            }
            if ($array_value == $value) $count++;
        }
        return array_filter($array);
    }
    
/**
  * Questo metodo formatta la data in modo standard
  * 
  * @param type $data
  * @return type 
  */
  public static function formattaData($data){

      $ret=null;
      $data=explode("-",$data);
      $time = mktime(0, 0, 0, $data[1], $data[2], $data[0]);
      $ret=date("d/m/Y", $time);
      return $ret;
  }
      
  

/**
 * Dato un numero lo trasforma in una stringa
 *
 * @param char (36) $id_utente
 */
public static function translitterazione($numero)
{
        $unita = array("","uno","due","tre","quattro","cinque","sei","sette","otto","nove");
        $decina1 = array("dieci","undici","dodici","tredici","quattordici","quindici","sedici","diciassette","diciotto","diciannove");
        $decine = array("","dieci","venti","trenta","quaranta","cinquanta","sessanta","settanta","ottanta","novanta");
        $decineTroncate = array("","","vent","trent","quarant","cinquant","sessant","settant","ottant","novant");
        $centinaia = array("","cento","duecento","trecento","quattrocento","cinquecento","seicento","settecento","ottocento","novecento");

        $numero=str_replace(".", ",", $numero);
        $parti = explode(",", $numero);

        if ($parti[1]=='')
        {
                $parti[1]='00';
        }

        // Inizializzo variabile contenente il risultato
        $risultato = "";

        // Faccio padding a 9 cifre
        $stringa = str_pad($parti[0], 9, "0", STR_PAD_LEFT);

        // Per ogni gruppo di tre cifre faccio il conto
        for($i=0;$i<9;$i=$i+3)
        {
                // Uso una variabile temporanea
                $tmp = "";

                // Centinaia
                $tmp .= $centinaia[$stringa[$i]];

                // Decine da 2 a 9
                if($stringa[$i+1] != "1")
                {
                        if($stringa[$i+2] == "1" || $stringa[$i+2] == "8")
                                $tmp = $tmp . $decineTroncate[$stringa[$i+1]];
                        else
                                $tmp = $tmp . $decine[$stringa[$i+1]];
                        $tmp = $tmp . $unita[$stringa[$i+2]];
                }
                else // Undici, dodici, tredici, ecc...
                {
                        $tmp .= $decina1[$stringa[$i+2]];
                }

                // Aggiungo suffissi quando necessario
                if($tmp != "" && $i==0)
                        $tmp .= "milioni";
                if($tmp != "" && $i==3)
                        $tmp .= "mila";

                // Aggiungo a risultato finale
                $risultato .= $tmp;

                // Caso speciale "mille" / "un milione" -> RISOLVE BUG "unmilioneunomilauno"
                if($i == 0 && $stringa[$i] == "0" && $stringa[$i+1] == "0")
                        $risultato = str_replace("unomilioni","unmilione",$risultato);
                if($i == 3 && $stringa[$i] == "0" && $stringa[$i+1] == "0")
                        $risultato = str_replace("unomila","mille",$risultato);
        }

        // ZERO!
        if($risultato == "")
                return "zero";
        else
                return  $risultato . "/" . $parti[1];
}
        
        
  
}

?>
